Clover icon

fastjson 1.2.60_preview_04

  1. Project Clover database Tue Apr 9 2024 16:11:52 CDT
  2. Package com.alibaba.fastjson.parser

File JSONScanner.java

 
 

Coverage histogram

../../../../img/srcFileCovDistChart8.png
31% of files have more coverage

Code metrics

1,012
1,853
51
1
2,976
2,584
760
0.41
36.33
51
14.9

Classes

Class Line # Actions
JSONScanner 31 1,853 0% 760 622
0.786694178.7%
 

Contributing tests

This file is covered by 2971 tests. .

Source view

1    /*
2    * Copyright 1999-2017 Alibaba Group.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    * http://www.apache.org/licenses/LICENSE-2.0
9    *
10    * Unless required by applicable law or agreed to in writing, software
11    * distributed under the License is distributed on an "AS IS" BASIS,
12    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13    * See the License for the specific language governing permissions and
14    * limitations under the License.
15    */
16    package com.alibaba.fastjson.parser;
17   
18    import com.alibaba.fastjson.JSON;
19    import com.alibaba.fastjson.JSONException;
20    import com.alibaba.fastjson.util.ASMUtils;
21    import com.alibaba.fastjson.util.IOUtils;
22   
23    import java.math.BigDecimal;
24    import java.util.*;
25   
26    //这个类，为了性能优化做了很多特别处理，一切都是为了性能！！！
27   
28    /**
29    * @author wenshao[szujobs@hotmail.com]
30    */
 
31    public final class JSONScanner extends JSONLexerBase {
32   
33    private final String text;
34    private final int len;
35   
 
36  43482 toggle public JSONScanner(String input){
37  43482 this(input, JSON.DEFAULT_PARSER_FEATURE);
38    }
39   
 
40  20099936 toggle public JSONScanner(String input, int features){
41  20099936 super(features);
42   
43  20099936 text = input;
44  20099936 len = text.length();
45  20099936 bp = -1;
46   
47  20099936 next();
48  20099936 if (ch == 65279) { // utf-8 bom
49  5 next();
50    }
51    }
52   
 
53  100764899 toggle public final char charAt(int index) {
54  100764899 if (index >= len) {
55  5027909 return EOI;
56    }
57   
58  95736990 return text.charAt(index);
59    }
60   
 
61  288449130 toggle public final char next() {
62  288449130 int index = ++bp;
63  288449130 return ch = (index >= this.len ? //
64    EOI //
65    : text.charAt(index));
66    }
67   
 
68  11 toggle public JSONScanner(char[] input, int inputLength){
69  11 this(input, inputLength, JSON.DEFAULT_PARSER_FEATURE);
70    }
71   
 
72  28 toggle public JSONScanner(char[] input, int inputLength, int features){
73  28 this(new String(input, 0, inputLength), features);
74    }
75   
 
76  33414 toggle protected final void copyTo(int offset, int count, char[] dest) {
77  33414 text.getChars(offset, offset + count, dest, 0);
78    }
79   
 
80  6203789 toggle static boolean charArrayCompare(String src, int offset, char[] dest) {
81  6203789 final int destLen = dest.length;
82  6203789 if (destLen + offset > src.length()) {
83  303 return false;
84    }
85   
86  34100474 for (int i = 0; i < destLen; ++i) {
87  30949449 if (dest[i] != src.charAt(offset + i)) {
88  3052461 return false;
89    }
90    }
91   
92  3151025 return true;
93    }
94   
 
95  6065849 toggle public final boolean charArrayCompare(char[] chars) {
96  6065849 return charArrayCompare(text, bp, chars);
97    }
98   
 
99  16834 toggle public final int indexOf(char ch, int startIndex) {
100  16834 return text.indexOf(ch, startIndex);
101    }
102   
 
103  5136027 toggle public final String addSymbol(int offset, int len, int hash, final SymbolTable symbolTable) {
104  5136027 return symbolTable.addSymbol(text, offset, len, hash);
105    }
106   
 
107  33 toggle public byte[] bytesValue() {
108  33 if (token == JSONToken.HEX) {
109  4 int start = np + 1, len = sp;
110  4 if (len % 2 != 0) {
111  0 throw new JSONException("illegal state. " + len);
112    }
113   
114  4 byte[] bytes = new byte[len / 2];
115  42 for (int i = 0; i < bytes.length; ++i) {
116  38 char c0 = text.charAt(start + i * 2);
117  38 char c1 = text.charAt(start + i * 2 + 1);
118   
119  38 int b0 = c0 - (c0 <= 57 ? 48 : 55);
120  38 int b1 = c1 - (c1 <= 57 ? 48 : 55);
121  38 bytes[i] = (byte) ((b0 << 4) | b1);
122    }
123   
124  4 return bytes;
125    }
126   
127  29 if (!hasSpecial) {
128  27 return IOUtils.decodeBase64(text, np + 1, sp);
129    } else {
130  2 String escapedText = new String(sbuf, 0, sp);
131  2 return IOUtils.decodeBase64(escapedText);
132    }
133    }
134   
135    /**
136    * The value of a literal token, recorded as a string. For integers, leading 0x and 'l' suffixes are suppressed.
137    */
 
138  157622 toggle public final String stringVal() {
139  157622 if (!hasSpecial) {
140  124216 return this.subString(np + 1, sp);
141    } else {
142  33406 return new String(sbuf, 0, sp);
143    }
144    }
145   
 
146  12669586 toggle public final String subString(int offset, int count) {
147  12669586 if (ASMUtils.IS_ANDROID) {
148  0 if (count < sbuf.length) {
149  0 text.getChars(offset, offset + count, sbuf, 0);
150  0 return new String(sbuf, 0, count);
151    } else {
152  0 char[] chars = new char[count];
153  0 text.getChars(offset, offset + count, chars, 0);
154  0 return new String(chars);
155    }
156    } else {
157  12669586 return text.substring(offset, offset + count);
158    }
159    }
160   
 
161  1091 toggle public final char[] sub_chars(int offset, int count) {
162  1091 if (ASMUtils.IS_ANDROID && count < sbuf.length) {
163  0 text.getChars(offset, offset + count, sbuf, 0);
164  0 return sbuf;
165    } else {
166  1091 char[] chars = new char[count];
167  1091 text.getChars(offset, offset + count, chars, 0);
168  1091 return chars;
169    }
170    }
171   
 
172  10005151 toggle public final String numberString() {
173  10005151 char chLocal = charAt(np + sp - 1);
174   
175  10005151 int sp = this.sp;
176  10005151 if (chLocal == 'L' || chLocal == 'S' || chLocal == 'B' || chLocal == 'F' || chLocal == 'D') {
177  4124 sp--;
178    }
179   
180  10005151 return this.subString(np, sp);
181    }
182   
 
183  4004254 toggle public final BigDecimal decimalValue() {
184  4004254 char chLocal = charAt(np + sp - 1);
185   
186  4004254 int sp = this.sp;
187  4004254 if (chLocal == 'L' || chLocal == 'S' || chLocal == 'B' || chLocal == 'F' || chLocal == 'D') {
188  3928 sp--;
189    }
190   
191  4004254 int offset = np, count = sp;
192  4004254 if (count < sbuf.length) {
193  4004254 text.getChars(offset, offset + count, sbuf, 0);
194  4004254 return new BigDecimal(sbuf, 0, count);
195    } else {
196  0 char[] chars = new char[count];
197  0 text.getChars(offset, offset + count, chars, 0);
198  0 return new BigDecimal(chars);
199    }
200    }
201   
 
202  43154 toggle public boolean scanISO8601DateIfMatch() {
203  43154 Test failure here return scanISO8601DateIfMatch(true);
204    }
205   
 
206  43252 toggle public boolean scanISO8601DateIfMatch(boolean strict) {
207  43252 int rest = len - bp;
208  43252 Test failure here return scanISO8601DateIfMatch(strict, rest);
209    }
210   
 
211  43325 toggle private boolean scanISO8601DateIfMatch(boolean strict, int rest) {
212  43325 if (rest < 8) {
213  20564 return false;
214    }
215   
216  22761 char c0 = charAt(bp);
217  22761 char c1 = charAt(bp + 1);
218  22761 char c2 = charAt(bp + 2);
219  22761 char c3 = charAt(bp + 3);
220  22761 char c4 = charAt(bp + 4);
221  22761 char c5 = charAt(bp + 5);
222  22761 char c6 = charAt(bp + 6);
223  22761 char c7 = charAt(bp + 7);
224   
225  22761 if ((!strict) && rest > 13) {
226  118 char c_r0 = charAt(bp + rest - 1);
227  118 char c_r1 = charAt(bp + rest - 2);
228  118 if (c0 == '/' && c1 == 'D' && c2 == 'a' && c3 == 't' && c4 == 'e' && c5 == '(' && c_r0 == '/'
229    && c_r1 == ')') {
230  16 int plusIndex = -1;
231  249 for (int i = 6; i < rest; ++i) {
232  249 char c = charAt(bp + i);
233  249 if (c == '+') {
234  5 plusIndex = i;
235  244 } else if (c < '0' || c > '9') {
236  16 break;
237    }
238    }
239  16 if (plusIndex == -1) {
240  11 return false;
241    }
242  5 int offset = bp + 6;
243  5 String numberText = this.subString(offset, bp + plusIndex - offset);
244  5 long millis = Long.parseLong(numberText);
245   
246  5 calendar = Calendar.getInstance(timeZone, locale);
247  5 calendar.setTimeInMillis(millis);
248   
249  5 token = JSONToken.LITERAL_ISO8601_DATE;
250  5 return true;
251    }
252    }
253   
254  22745 char c10;
255  ? if (rest == 8
256    || rest == 14
257    || (rest == 16 && ((c10 = charAt(bp + 10)) == 'T' || c10 == ' '))
258    || (rest == 17 && charAt(bp + 6) != '-')) {
259  1749 if (strict) {
260  1723 return false;
261    }
262   
263  26 char y0, y1, y2, y3, M0, M1, d0, d1;
264   
265   
266   
267  26 char c8 = charAt(bp + 8);
268   
269  26 final boolean c_47 = c4 == '-' && c7 == '-';
270  26 final boolean sperate16 = c_47 && rest == 16;
271  26 final boolean sperate17 = c_47 && rest == 17;
272  26 if (sperate17 || sperate16) {
273  4 y0 = c0;
274  4 y1 = c1;
275  4 y2 = c2;
276  4 y3 = c3;
277  4 M0 = c5;
278  4 M1 = c6;
279  4 d0 = c8;
280  4 d1 = charAt(bp + 9);
281  22 } else if (c4 == '-' && c6 == '-') {
282  1 y0 = c0;
283  1 y1 = c1;
284  1 y2 = c2;
285  1 y3 = c3;
286  1 M0 = '0';
287  1 M1 = c5;
288  1 d0 = '0';
289  1 d1 = c7;
290    } else {
291  21 y0 = c0;
292  21 y1 = c1;
293  21 y2 = c2;
294  21 y3 = c3;
295  21 M0 = c4;
296  21 M1 = c5;
297  21 d0 = c6;
298  21 d1 = c7;
299    }
300   
301   
302  26 if (!checkDate(y0, y1, y2, y3, M0, M1, d0, d1)) {
303  2 return false;
304    }
305   
306  24 setCalendar(y0, y1, y2, y3, M0, M1, d0, d1);
307   
308  24 int hour, minute, seconds, millis;
309  24 if (rest != 8) {
310  21 char c9 = charAt(bp + 9);
311  21 c10 = charAt(bp + 10);
312  21 char c11 = charAt(bp + 11);
313  21 char c12 = charAt(bp + 12);
314  21 char c13 = charAt(bp + 13);
315   
316  21 char h0, h1, m0, m1, s0, s1;
317   
318  21 if ((sperate17 && c10 == 'T' && c13 == ':' && charAt(bp + 16) == 'Z')
319    || (sperate16 && (c10 == ' ' || c10 == 'T') && c13 == ':')) {
320  4 h0 = c11;
321  4 h1 = c12;
322  4 m0 = charAt(bp + 14);
323  4 m1 = charAt(bp + 15);
324  4 s0 = '0';
325  4 s1 = '0';
326    } else {
327  17 h0 = c8;
328  17 h1 = c9;
329  17 m0 = c10;
330  17 m1 = c11;
331  17 s0 = c12;
332  17 s1 = c13;
333    }
334   
335  21 if (!checkTime(h0, h1, m0, m1, s0, s1)) {
336  2 return false;
337    }
338   
339  19 if (rest == 17 && !sperate17) {
340  13 char S0 = charAt(bp + 14);
341  13 char S1 = charAt(bp + 15);
342  13 char S2 = charAt(bp + 16);
343  13 if (S0 < '0' || S0 > '9') {
344  4 return false;
345    }
346  9 if (S1 < '0' || S1 > '9') {
347  4 return false;
348    }
349  5 if (S2 < '0' || S2 > '9') {
350  4 return false;
351    }
352   
353  1 millis = (S0 - '0') * 100 + (S1 - '0') * 10 + (S2 - '0');
354    } else {
355  6 millis = 0;
356    }
357   
358  7 hour = (h0 - '0') * 10 + (h1 - '0');
359  7 minute = (m0 - '0') * 10 + (m1 - '0');
360  7 seconds = (s0 - '0') * 10 + (s1 - '0');
361    } else {
362  3 hour = 0;
363  3 minute = 0;
364  3 seconds = 0;
365  3 millis = 0;
366    }
367   
368  10 calendar.set(Calendar.HOUR_OF_DAY, hour);
369  10 calendar.set(Calendar.MINUTE, minute);
370  10 calendar.set(Calendar.SECOND, seconds);
371  10 calendar.set(Calendar.MILLISECOND, millis);
372   
373  10 token = JSONToken.LITERAL_ISO8601_DATE;
374  10 return true;
375    }
376   
377  20996 if (rest < 9) {
378  0 return false;
379    }
380   
381  20996 char c8 = charAt(bp + 8);
382  20996 char c9 = charAt(bp + 9);
383   
384  20996 int date_len = 10;
385  20996 char y0, y1, y2, y3, M0, M1, d0, d1;
386  20996 if ((c4 == '-' && c7 == '-') // cn
387    || (c4 == '/' && c7 == '/') // tw yyyy/mm/dd
388    ) {
389  1179 y0 = c0;
390  1179 y1 = c1;
391  1179 y2 = c2;
392  1179 y3 = c3;
393  1179 M0 = c5;
394  1179 M1 = c6;
395  1179 d0 = c8;
396  1179 d1 = c9;
397  19817 } else if ((c4 == '-' && c6 == '-') // cn yyyy-m-dd
398    ) {
399  2 y0 = c0;
400  2 y1 = c1;
401  2 y2 = c2;
402  2 y3 = c3;
403  2 M0 = '0';
404  2 M1 = c5;
405   
406  2 if (c8 == ' ') {
407  1 d0 = '0';
408  1 d1 = c7;
409  1 date_len = 8;
410    } else {
411  1 d0 = c7;
412  1 d1 = c8;
413  1 date_len = 9;
414    }
415  19815 } else if ((c2 == '.' && c5 == '.') // de dd.mm.yyyy
416    || (c2 == '-' && c5 == '-') // in dd-mm-yyyy
417    ) {
418  1560 d0 = c0;
419  1560 d1 = c1;
420  1560 M0 = c3;
421  1560 M1 = c4;
422  1560 y0 = c6;
423  1560 y1 = c7;
424  1560 y2 = c8;
425  1560 y3 = c9;
426  18255 } else if (c8 == 'T') {
427  1 y0 = c0;
428  1 y1 = c1;
429  1 y2 = c2;
430  1 y3 = c3;
431  1 M0 = c4;
432  1 M1 = c5;
433  1 d0 = c6;
434  1 d1 = c7;
435  1 date_len = 8;
436    } else {
437  18254 if (c4 == '年' || c4 == '년') {
438  61 y0 = c0;
439  61 y1 = c1;
440  61 y2 = c2;
441  61 y3 = c3;
442   
443  61 if (c7 == '月' || c7 == '월') {
444  47 M0 = c5;
445  47 M1 = c6;
446  47 if (c9 == '日' || c9 == '일') {
447  2 d0 = '0';
448  2 d1 = c8;
449  45 } else if (charAt(bp + 10) == '日' || charAt(bp + 10) == '일'){
450  45 d0 = c8;
451  45 d1 = c9;
452  45 date_len = 11;
453    } else {
454  0 return false;
455    }
456  14 } else if (c6 == '月' || c6 == '월') {
457  8 M0 = '0';
458  8 M1 = c5;
459  8 if (c8 == '日' || c8 == '일') {
460  6 d0 = '0';
461  6 d1 = c7;
462  2 } else if (c9 == '日' || c9 == '일'){
463  2 d0 = c7;
464  2 d1 = c8;
465    } else {
466  0 return false;
467    }
468    } else {
469  6 return false;
470    }
471    } else {
472  18193 return false;
473    }
474    }
475   
476  2797 if (!checkDate(y0, y1, y2, y3, M0, M1, d0, d1)) {
477  1588 return false;
478    }
479   
480  1209 Test failure here setCalendar(y0, y1, y2, y3, M0, M1, d0, d1);
481   
482  1199 char t = charAt(bp + date_len);
483  1199 if (t == 'T' && rest == 16 && date_len == 8 && charAt(bp + 15) == 'Z') {
484  1 char h0 = charAt(bp + date_len + 1);
485  1 char h1 = charAt(bp + date_len + 2);
486  1 char m0 = charAt(bp + date_len + 3);
487  1 char m1 = charAt(bp + date_len + 4);
488  1 char s0 = charAt(bp + date_len + 5);
489  1 char s1 = charAt(bp + date_len + 6);
490   
491  1 if (!checkTime(h0, h1, m0, m1, s0, s1)) {
492  0 return false;
493    }
494   
495  1 setTime(h0, h1, m0, m1, s0, s1);
496  1 calendar.set(Calendar.MILLISECOND, 0);
497   
498  1 if (calendar.getTimeZone().getRawOffset() != 0) {
499  1 String[] timeZoneIDs = TimeZone.getAvailableIDs(0);
500  1 if (timeZoneIDs.length > 0) {
501  1 TimeZone timeZone = TimeZone.getTimeZone(timeZoneIDs[0]);
502  1 calendar.setTimeZone(timeZone);
503    }
504    }
505   
506  1 token = JSONToken.LITERAL_ISO8601_DATE;
507  1 return true;
508  1198 } else if (t == 'T' || (t == ' ' && !strict)) {
509  128 if (rest < date_len + 9) { // "0000-00-00T00:00:00".length()
510  1 return false;
511    }
512  1070 } else if (t == '"' || t == EOI || t == '日' || t == '일') {
513  90 calendar.set(Calendar.HOUR_OF_DAY, 0);
514  90 calendar.set(Calendar.MINUTE, 0);
515  90 calendar.set(Calendar.SECOND, 0);
516  90 calendar.set(Calendar.MILLISECOND, 0);
517   
518  90 ch = charAt(bp += date_len);
519   
520  90 token = JSONToken.LITERAL_ISO8601_DATE;
521  90 return true;
522  980 } else if (t == '+' || t == '-') {
523  5 if (len == date_len + 6) {
524  3 if (charAt(bp + date_len + 3) != ':' //
525    || charAt(bp + date_len + 4) != '0' //
526    || charAt(bp + date_len + 5) != '0') {
527  0 return false;
528    }
529   
530  3 setTime('0', '0', '0', '0', '0', '0');
531  3 calendar.set(Calendar.MILLISECOND, 0);
532  3 setTimeZone(t, charAt(bp + date_len + 1), charAt(bp + date_len + 2));
533  3 return true;
534    }
535  2 return false;
536    } else {
537  975 return false;
538    }
539   
540  127 if (charAt(bp + date_len + 3) != ':') {
541  2 return false;
542    }
543  125 if (charAt(bp + date_len + 6) != ':') {
544  1 return false;
545    }
546   
547  124 char h0 = charAt(bp + date_len + 1);
548  124 char h1 = charAt(bp + date_len + 2);
549  124 char m0 = charAt(bp + date_len + 4);
550  124 char m1 = charAt(bp + date_len + 5);
551  124 char s0 = charAt(bp + date_len + 7);
552  124 char s1 = charAt(bp + date_len + 8);
553   
554  124 if (!checkTime(h0, h1, m0, m1, s0, s1)) {
555  20 return false;
556    }
557   
558  104 setTime(h0, h1, m0, m1, s0, s1);
559   
560  104 char dot = charAt(bp + date_len + 9);
561  104 int millisLen = -1; // 有可能没有毫秒区域，没有毫秒区域的时候下一个字符位置有可能是'Z'、'+'、'-'
562  104 int millis = 0;
563  104 if (dot == '.') { // 0000-00-00T00:00:00.000
564  50 if (rest < date_len + 11) {
565  1 return false;
566    }
567   
568  49 char S0 = charAt(bp + date_len + 10);
569  49 if (S0 < '0' || S0 > '9') {
570  2 return false;
571    }
572  47 millis = S0 - '0';
573  47 millisLen = 1;
574   
575  47 if (rest > date_len + 11) {
576  46 char S1 = charAt(bp + date_len + 11);
577  46 if (S1 >= '0' && S1 <= '9') {
578  43 millis = millis * 10 + (S1 - '0');
579  43 millisLen = 2;
580    }
581    }
582   
583  47 if (millisLen == 2) {
584  43 char S2 = charAt(bp + date_len + 12);
585  43 if (S2 >= '0' && S2 <= '9') {
586  39 millis = millis * 10 + (S2 - '0');
587  39 millisLen = 3;
588    }
589    }
590    }
591  101 calendar.set(Calendar.MILLISECOND, millis);
592   
593  101 int timzeZoneLength = 0;
594  101 char timeZoneFlag = charAt(bp + date_len + 10 + millisLen);
595   
596  101 if (timeZoneFlag == ' ') {
597  1 millisLen++;
598  1 timeZoneFlag = charAt(bp + date_len + 10 + millisLen);
599    }
600   
601  101 if (timeZoneFlag == '+' || timeZoneFlag == '-') {
602  23 char t0 = charAt(bp + date_len + 10 + millisLen + 1);
603  23 if (t0 < '0' || t0 > '1') {
604  0 return false;
605    }
606   
607  23 char t1 = charAt(bp + date_len + 10 + millisLen + 2);
608  23 if (t1 < '0' || t1 > '9') {
609  0 return false;
610    }
611   
612  23 char t2 = charAt(bp + date_len + 10 + millisLen + 3);
613  23 char t3 = '0', t4 = '0';
614  23 if (t2 == ':') { // ThreeLetterISO8601TimeZone
615  15 t3 = charAt(bp + date_len + 10 + millisLen + 4);
616  15 if (t3 != '0' && t3 != '3') {
617  0 return false;
618    }
619   
620  15 t4 = charAt(bp + date_len + 10 + millisLen + 5);
621  15 if (t4 != '0') {
622  0 return false;
623    }
624  15 timzeZoneLength = 6;
625  8 } else if (t2 == '0') { // TwoLetterISO8601TimeZone
626  3 t3 = charAt(bp + date_len + 10 + millisLen + 4);
627  3 if (t3 != '0' && t3 != '3') {
628  0 return false;
629    }
630  3 timzeZoneLength = 5;
631  5 } else if (t2 == '3' && charAt(bp + date_len + 10 + millisLen + 4) == '0') {
632  1 t3 = '3';
633  1 t4 = '0';
634  1 timzeZoneLength = 5;
635  4 } else if (t2 == '4' && charAt(bp + date_len + 10 + millisLen + 4) == '5') {
636  3 t3 = '4';
637  3 t4 = '5';
638  3 timzeZoneLength = 5;
639    } else {
640  1 timzeZoneLength = 3;
641    }
642   
643  23 setTimeZone(timeZoneFlag, t0, t1, t3, t4);
644   
645  78 } else if (timeZoneFlag == 'Z') {// UTC
646  8 timzeZoneLength = 1;
647  8 if (calendar.getTimeZone().getRawOffset() != 0) {
648  8 String[] timeZoneIDs = TimeZone.getAvailableIDs(0);
649  8 if (timeZoneIDs.length > 0) {
650  8 TimeZone timeZone = TimeZone.getTimeZone(timeZoneIDs[0]);
651  8 calendar.setTimeZone(timeZone);
652    }
653    }
654    }
655   
656  101 char end = charAt(bp + (date_len + 10 + millisLen + timzeZoneLength));
657  101 if (end != EOI && end != '"') {
658  9 return false;
659    }
660  92 ch = charAt(bp += (date_len + 10 + millisLen + timzeZoneLength));
661   
662  92 token = JSONToken.LITERAL_ISO8601_DATE;
663  92 return true;
664    }
665   
 
666  108 toggle protected void setTime(char h0, char h1, char m0, char m1, char s0, char s1) {
667  108 int hour = (h0 - '0') * 10 + (h1 - '0');
668  108 int minute = (m0 - '0') * 10 + (m1 - '0');
669  108 int seconds = (s0 - '0') * 10 + (s1 - '0');
670  108 calendar.set(Calendar.HOUR_OF_DAY, hour);
671  108 calendar.set(Calendar.MINUTE, minute);
672  108 calendar.set(Calendar.SECOND, seconds);
673    }
674   
 
675  3 toggle protected void setTimeZone(char timeZoneFlag, char t0, char t1) {
676  3 setTimeZone(timeZoneFlag, t0, t1, '0', '0');
677    }
678   
 
679  26 toggle protected void setTimeZone(char timeZoneFlag, char t0, char t1, char t3, char t4) {
680  26 int timeZoneOffset = ((t0 - '0') * 10 + (t1 - '0')) * 3600 * 1000;
681   
682  26 timeZoneOffset += ((t3 - '0') * 10 + (t4 - '0')) * 60 * 1000;
683   
684  26 if (timeZoneFlag == '-') {
685  2 timeZoneOffset = -timeZoneOffset;
686    }
687   
688  26 if (calendar.getTimeZone().getRawOffset() != timeZoneOffset) {
689  14 String[] timeZoneIDs = TimeZone.getAvailableIDs(timeZoneOffset);
690  14 if (timeZoneIDs.length > 0) {
691  13 TimeZone timeZone = TimeZone.getTimeZone(timeZoneIDs[0]);
692  13 calendar.setTimeZone(timeZone);
693    }
694    }
695    }
696   
 
697  146 toggle private boolean checkTime(char h0, char h1, char m0, char m1, char s0, char s1) {
698  146 if (h0 == '0') {
699  64 if (h1 < '0' || h1 > '9') {
700  2 return false;
701    }
702  82 } else if (h0 == '1') {
703  65 if (h1 < '0' || h1 > '9') {
704  2 return false;
705    }
706  17 } else if (h0 == '2') {
707  16 if (h1 < '0' || h1 > '4') {
708  4 return false;
709    }
710    } else {
711  1 return false;
712    }
713   
714  137 if (m0 >= '0' && m0 <= '5') {
715  133 if (m1 < '0' || m1 > '9') {
716  4 return false;
717    }
718  4 } else if (m0 == '6') {
719  2 if (m1 != '0') {
720  1 return false;
721    }
722    } else {
723  2 return false;
724    }
725   
726  130 if (s0 >= '0' && s0 <= '5') {
727  125 if (s1 < '0' || s1 > '9') {
728  2 return false;
729    }
730  5 } else if (s0 == '6') {
731  2 if (s1 != '0') {
732  1 return false;
733    }
734    } else {
735  3 return false;
736    }
737   
738  124 return true;
739    }
740   
 
741  1233 toggle private void setCalendar(char y0, char y1, char y2, char y3, char M0, char M1, char d0, char d1) {
742  1233 Test failure here calendar = Calendar.getInstance(timeZone, locale);
743  1223 int year = (y0 - '0') * 1000 + (y1 - '0') * 100 + (y2 - '0') * 10 + (y3 - '0');
744  1223 int month = (M0 - '0') * 10 + (M1 - '0') - 1;
745  1223 int day = (d0 - '0') * 10 + (d1 - '0');
746    // calendar.set(year, month, day);
747  1223 calendar.set(Calendar.YEAR, year);
748  1223 calendar.set(Calendar.MONTH, month);
749  1223 calendar.set(Calendar.DAY_OF_MONTH, day);
750    }
751   
 
752  2823 toggle static boolean checkDate(char y0, char y1, char y2, char y3, char M0, char M1, int d0, int d1) {
753  2823 if (y0 < '0' || y0 > '9') {
754  1560 return false;
755    }
756  1263 if (y1 < '0' || y1 > '9') {
757  2 return false;
758    }
759  1261 if (y2 < '0' || y2 > '9') {
760  3 return false;
761    }
762  1258 if (y3 < '0' || y3 > '9') {
763  2 return false;
764    }
765   
766  1256 if (M0 == '0') {
767  960 if (M1 < '1' || M1 > '9') {
768  9 return false;
769    }
770  296 } else if (M0 == '1') {
771  292 if (M1 != '0' && M1 != '1' && M1 != '2') {
772  3 return false;
773    }
774    } else {
775  4 return false;
776    }
777   
778  1240 if (d0 == '0') {
779  644 if (d1 < '1' || d1 > '9') {
780  3 return false;
781    }
782  596 } else if (d0 == '1' || d0 == '2') {
783  376 if (d1 < '0' || d1 > '9') {
784  2 return false;
785    }
786  220 } else if (d0 == '3') {
787  219 if (d1 != '0' && d1 != '1') {
788  1 return false;
789    }
790    } else {
791  1 return false;
792    }
793   
794  1233 return true;
795    }
796   
 
797  5021882 toggle @Override
798    public boolean isEOF() {
799  5021882 return bp == len || (ch == EOI && bp + 1 >= len);
800    }
801   
 
802  84483 toggle public int scanFieldInt(char[] fieldName) {
803  84483 matchStat = UNKNOWN;
804  84483 int startPos = this.bp;
805  84483 char startChar = this.ch;
806   
807  84483 if (!charArrayCompare(text, bp, fieldName)) {
808  1731 matchStat = NOT_MATCH_NAME;
809  1731 return 0;
810    }
811   
812  82752 int index = bp + fieldName.length;
813   
814  82752 char ch = charAt(index++);
815   
816  82752 final boolean quote = ch == '"';
817   
818  82752 if (quote) {
819  22 ch = charAt(index++);
820    }
821   
822  82752 final boolean negative = ch == '-';
823  82752 if (negative) {
824  1 ch = charAt(index++);
825    }
826   
827  82752 int value;
828  82752 if (ch >= '0' && ch <= '9') {
829  82714 value = ch - '0';
830  82714 for (;;) {
831  155184 ch = charAt(index++);
832  155184 if (ch >= '0' && ch <= '9') {
833  72473 int value_10 = value * 10;
834  72473 if (value_10 < value) {
835  3 matchStat = NOT_MATCH;
836  3 return 0;
837    }
838   
839  72470 value = value_10 + (ch - '0');
840  82711 } else if (ch == '.') {
841  350 matchStat = NOT_MATCH;
842  350 return 0;
843    } else {
844  82361 break;
845    }
846    }
847   
848  82361 if (value < 0) {
849  6 matchStat = NOT_MATCH;
850  6 return 0;
851    }
852   
853  82355 if (quote) {
854  8 if (ch != '"') {
855  0 matchStat = NOT_MATCH;
856  0 return 0;
857    } else {
858  8 ch = charAt(index++);
859    }
860    }
861   
862  82355 for (;;) {
863  82361 if (ch == ',' || ch == '}') {
864  82349 bp = index - 1;
865  82349 break;
866  12 } else if(isWhitespace(ch)) {
867  6 ch = charAt(index++);
868  6 continue;
869    } else {
870  6 matchStat = NOT_MATCH;
871  6 return 0;
872    }
873    }
874    } else {
875  38 matchStat = NOT_MATCH;
876  38 return 0;
877    }
878   
879  82349 if (ch == ',') {
880  61699 this.ch = charAt(++bp);
881  61699 matchStat = VALUE;
882  61699 token = JSONToken.COMMA;
883  61699 return negative ? -value : value;
884    }
885   
886  20650 if (ch == '}') {
887  20650 bp = index - 1;
888  20650 ch = charAt(++bp);
889  20650 for (; ; ) {
890  20657 if (ch == ',') {
891  20498 token = JSONToken.COMMA;
892  20498 this.ch = charAt(++bp);
893  20498 break;
894  159 } else if (ch == ']') {
895  31 token = JSONToken.RBRACKET;
896  31 this.ch = charAt(++bp);
897  31 break;
898  128 } else if (ch == '}') {
899  22 token = JSONToken.RBRACE;
900  22 this.ch = charAt(++bp);
901  22 break;
902  106 } else if (ch == EOI) {
903  98 token = JSONToken.EOF;
904  98 break;
905  7 } else if (isWhitespace(ch)) {
906  7 ch = charAt(++bp);
907  7 continue;
908    } else {
909  0 this.bp = startPos;
910  0 this.ch = startChar;
911  0 matchStat = NOT_MATCH;
912  0 return 0;
913    }
914    }
915  20649 matchStat = END;
916    }
917   
918  20649 return negative ? -value : value;
919    }
920   
 
921  16033 toggle public String scanFieldString(char[] fieldName) {
922  16033 matchStat = UNKNOWN;
923  16033 int startPos = this.bp;
924  16033 char startChar = this.ch;
925   
926  16033 for (;;) {
927  16289 if (!charArrayCompare(text, bp, fieldName)) {
928  650 if (isWhitespace(ch)) {
929  256 next();
930  256 continue;
931    }
932  394 matchStat = NOT_MATCH_NAME;
933  394 return stringDefaultValue();
934    } else {
935  15639 break;
936    }
937    }
938   
939  15639 int index = bp + fieldName.length;
940   
941  15639 char ch = charAt(index++);
942  15639 if (ch != '"') {
943  67 matchStat = NOT_MATCH;
944   
945  67 return stringDefaultValue();
946    }
947   
948  15572 final String strVal;
949    {
950  15572 int startIndex = index;
951  15572 int endIndex = indexOf('"', startIndex);
952  15572 if (endIndex == -1) {
953  1 throw new JSONException("unclosed str");
954    }
955   
956  15571 String stringVal = subString(startIndex, endIndex - startIndex);
957  15571 if (stringVal.indexOf('\\') != -1) {
958  1076 for (;;) {
959  1124 int slashCount = 0;
960  1178 for (int i = endIndex - 1; i >= 0; --i) {
961  1178 if (charAt(i) == '\\') {
962  54 slashCount++;
963    } else {
964  1124 break;
965    }
966    }
967  1124 if (slashCount % 2 == 0) {
968  1076 break;
969    }
970  48 endIndex = indexOf('"', endIndex + 1);
971    }
972   
973  1076 int chars_len = endIndex - (bp + fieldName.length + 1);
974  1076 char[] chars = sub_chars(bp + fieldName.length + 1, chars_len);
975   
976  1076 stringVal = readString(chars, chars_len);
977    }
978   
979  15571 ch = charAt(endIndex + 1);
980   
981  15571 for (;;) {
982  15600 if (ch == ',' || ch == '}') {
983  15569 bp = endIndex + 1;
984  15569 this.ch = ch;
985  15569 strVal = stringVal;
986  15569 break;
987  31 } else if (isWhitespace(ch)) {
988  29 endIndex++;
989  29 ch = charAt(endIndex + 1);
990    } else {
991  2 matchStat = NOT_MATCH;
992   
993  2 return stringDefaultValue();
994    }
995    }
996    }
997   
998  15569 if (ch == ',') {
999  12233 this.ch = charAt(++bp);
1000  12233 matchStat = VALUE;
1001  12233 return strVal;
1002    } else {
1003    //condition ch == '}' is always 'true'
1004  3336 ch = charAt(++bp);
1005  3336 if (ch == ',') {
1006  3062 token = JSONToken.COMMA;
1007  3062 this.ch = charAt(++bp);
1008  274 } else if (ch == ']') {
1009  53 token = JSONToken.RBRACKET;
1010  53 this.ch = charAt(++bp);
1011  221 } else if (ch == '}') {
1012  25 token = JSONToken.RBRACE;
1013  25 this.ch = charAt(++bp);
1014  196 } else if (ch == EOI) {
1015  184 token = JSONToken.EOF;
1016    } else {
1017  12 this.bp = startPos;
1018  12 this.ch = startChar;
1019  12 matchStat = NOT_MATCH;
1020  12 return stringDefaultValue();
1021    }
1022  3324 matchStat = END;
1023    }
1024  3324 return strVal;
1025    }
1026   
 
1027  713 toggle public java.util.Date scanFieldDate(char[] fieldName) {
1028  713 matchStat = UNKNOWN;
1029  713 int startPos = this.bp;
1030  713 char startChar = this.ch;
1031   
1032  713 if (!charArrayCompare(text, bp, fieldName)) {
1033  549 matchStat = NOT_MATCH_NAME;
1034  549 return null;
1035    }
1036   
1037  164 int index = bp + fieldName.length;
1038   
1039  164 char ch = charAt(index++);
1040   
1041  164 final java.util.Date dateVal;
1042  164 if (ch == '"') {
1043  72 int startIndex = index;
1044  72 int endIndex = indexOf('"', startIndex);
1045  72 if (endIndex == -1) {
1046  1 throw new JSONException("unclosed str");
1047    }
1048   
1049  71 int rest = endIndex - startIndex;
1050  71 bp = index;
1051  71 if (scanISO8601DateIfMatch(false, rest)) {
1052  43 dateVal = calendar.getTime();
1053    } else {
1054  28 bp = startPos;
1055  28 matchStat = NOT_MATCH;
1056  28 return null;
1057    }
1058  43 ch = charAt(endIndex + 1);
1059  43 bp = startPos;
1060   
1061  43 for (; ; ) {
1062  43 if (ch == ',' || ch == '}') {
1063  43 bp = endIndex + 1;
1064  43 this.ch = ch;
1065  43 break;
1066  0 } else if (isWhitespace(ch)) {
1067  0 endIndex++;
1068  0 ch = charAt(endIndex + 1);
1069    } else {
1070  0 matchStat = NOT_MATCH;
1071   
1072  0 return null;
1073    }
1074    }
1075  92 } else if (ch == '-' || (ch >= '0' && ch <= '9')) {
1076  69 long millis = 0;
1077   
1078  69 boolean negative = false;
1079  69 if (ch == '-') {
1080  0 ch = charAt(index++);
1081  0 negative = true;
1082    }
1083   
1084  69 if (ch >= '0' && ch <= '9') {
1085  69 millis = ch - '0';
1086  69 for (; ; ) {
1087  886 ch = charAt(index++);
1088  886 if (ch >= '0' && ch <= '9') {
1089  817 millis = millis * 10 + (ch - '0');
1090    } else {
1091  68 if (ch == ',' || ch == '}') {
1092  68 bp = index - 1;
1093    }
1094  69 break;
1095    }
1096    }
1097    }
1098   
1099  69 if (millis < 0) {
1100  0 matchStat = NOT_MATCH;
1101  0 return null;
1102    }
1103   
1104  69 if (negative) {
1105  0 millis = -millis;
1106    }
1107   
1108  69 dateVal = new java.util.Date(millis);
1109    } else {
1110  23 matchStat = NOT_MATCH;
1111   
1112  23 return null;
1113    }
1114   
1115  112 if (ch == ',') {
1116  70 this.ch = charAt(++bp);
1117  70 matchStat = VALUE;
1118  70 token = JSONToken.COMMA;
1119  70 return dateVal;
1120    } else {
1121    //condition ch == '}' is always 'true'
1122  42 ch = charAt(++bp);
1123  42 if (ch == ',') {
1124  0 token = JSONToken.COMMA;
1125  0 this.ch = charAt(++bp);
1126  42 } else if (ch == ']') {
1127  0 token = JSONToken.RBRACKET;
1128  0 this.ch = charAt(++bp);
1129  42 } else if (ch == '}') {
1130  1 token = JSONToken.RBRACE;
1131  1 this.ch = charAt(++bp);
1132  40 } else if (ch == EOI) {
1133  40 token = JSONToken.EOF;
1134    } else {
1135  0 this.bp = startPos;
1136  0 this.ch = startChar;
1137  0 matchStat = NOT_MATCH;
1138  0 return null;
1139    }
1140  41 matchStat = END;
1141    }
1142  41 return dateVal;
1143    }
1144   
 
1145  7 toggle public long scanFieldSymbol(char[] fieldName) {
1146  7 matchStat = UNKNOWN;
1147   
1148  7 if (!charArrayCompare(text, bp, fieldName)) {
1149  0 matchStat = NOT_MATCH_NAME;
1150  0 return 0;
1151    }
1152   
1153  7 int index = bp + fieldName.length;
1154   
1155  7 char ch = charAt(index++);
1156  7 if (ch != '"') {
1157  0 matchStat = NOT_MATCH;
1158  0 return 0;
1159    }
1160   
1161  7 long hash = 0xcbf29ce484222325L;
1162  7 for (;;) {
1163  23 ch = charAt(index++);
1164  23 if (ch == '\"') {
1165  7 bp = index;
1166  7 this.ch = ch = charAt(bp);
1167  7 break;
1168  16 } else if (index > len) {
1169  0 matchStat = NOT_MATCH;
1170  0 return 0;
1171    }
1172   
1173  16 hash ^= ch;
1174  16 hash *= 0x100000001b3L;
1175    }
1176   
1177  7 for (;;) {
1178  7 if (ch == ',') {
1179  0 this.ch = charAt(++bp);
1180  0 matchStat = VALUE;
1181  0 return hash;
1182  7 } else if (ch == '}') {
1183  5 next();
1184  5 skipWhitespace();
1185  5 ch = getCurrent();
1186  5 if (ch == ',') {
1187  1 token = JSONToken.COMMA;
1188  1 this.ch = charAt(++bp);
1189  4 } else if (ch == ']') {
1190  1 token = JSONToken.RBRACKET;
1191  1 this.ch = charAt(++bp);
1192  3 } else if (ch == '}') {
1193  1 token = JSONToken.RBRACE;
1194  1 this.ch = charAt(++bp);
1195  2 } else if (ch == EOI) {
1196  1 token = JSONToken.EOF;
1197    } else {
1198  1 matchStat = NOT_MATCH;
1199  1 return 0;
1200    }
1201  4 matchStat = END;
1202  4 break;
1203  2 } else if (isWhitespace(ch)) {
1204  0 ch = charAt(++bp);
1205  0 continue;
1206    } else {
1207  2 matchStat = NOT_MATCH;
1208  2 return 0;
1209    }
1210    }
1211   
1212  4 return hash;
1213    }
1214   
 
1215  1 toggle public Collection<String> newCollectionByType(Class<?> type){
1216  1 if (type.isAssignableFrom(HashSet.class)) {
1217  0 HashSet<String> list = new HashSet<String>();
1218  0 return list;
1219  1 } else if (type.isAssignableFrom(ArrayList.class)) {
1220  1 ArrayList<String> list2 = new ArrayList<String>();
1221  1 return list2;
1222    } else {
1223  0 try {
1224  0 Collection<String> list = (Collection<String>) type.newInstance();
1225  0 return list;
1226    } catch (Exception e) {
1227  0 throw new JSONException(e.getMessage(), e);
1228    }
1229    }
1230    }
1231   
 
1232  1 toggle @SuppressWarnings("unchecked")
1233    public Collection<String> scanFieldStringArray(char[] fieldName, Class<?> type) {
1234  1 matchStat = UNKNOWN;
1235   
1236  1 while (ch == '\n' || ch == ' ') {
1237  0 int index = ++bp;
1238  0 ch = (index >= this.len ? //
1239    EOI //
1240    : text.charAt(index));
1241    }
1242   
1243  1 if (!charArrayCompare(text, bp, fieldName)) {
1244  0 matchStat = NOT_MATCH_NAME;
1245  0 return null;
1246    }
1247   
1248  1 Collection<String> list = newCollectionByType(type);
1249   
1250    // if (type.isAssignableFrom(HashSet.class)) {
1251    // list = new HashSet<String>();
1252    // } else if (type.isAssignableFrom(ArrayList.class)) {
1253    // list = new ArrayList<String>();
1254    // } else {
1255    // try {
1256    // list = (Collection<String>) type.newInstance();
1257    // } catch (Exception e) {
1258    // throw new JSONException(e.getMessage(), e);
1259    // }
1260    // }
1261   
1262  1 int startPos = this.bp;
1263  1 char startChar = this.ch;
1264   
1265  1 int index = bp + fieldName.length;
1266   
1267  1 char ch = charAt(index++);
1268   
1269  1 if (ch == '[') {
1270  1 ch = charAt(index++);
1271   
1272  1 for (;;) {
1273  2 if (ch == '"') {
1274  2 int startIndex = index;
1275  2 int endIndex = indexOf('"', startIndex);
1276  2 if (endIndex == -1) {
1277  0 throw new JSONException("unclosed str");
1278    }
1279   
1280  2 String stringVal = subString(startIndex, endIndex - startIndex);
1281  2 if (stringVal.indexOf('\\') != -1) {
1282  0 for (;;) {
1283  0 int slashCount = 0;
1284  0 for (int i = endIndex - 1; i >= 0; --i) {
1285  0 if (charAt(i) == '\\') {
1286  0 slashCount++;
1287    } else {
1288  0 break;
1289    }
1290    }
1291  0 if (slashCount % 2 == 0) {
1292  0 break;
1293    }
1294  0 endIndex = indexOf('"', endIndex + 1);
1295    }
1296   
1297  0 int chars_len = endIndex - startIndex;
1298  0 char[] chars = sub_chars(startIndex, chars_len);
1299   
1300  0 stringVal = readString(chars, chars_len);
1301    }
1302   
1303  2 index = endIndex + 1;
1304  2 ch = charAt(index++);
1305   
1306  2 list.add(stringVal);
1307  0 } else if (ch == 'n' && text.startsWith("ull", index)) {
1308  0 index += 3;
1309  0 ch = charAt(index++);
1310  0 list.add(null);
1311  0 } else if (ch == ']' && list.size() == 0) {
1312  0 ch = charAt(index++);
1313  0 break;
1314    } else {
1315  0 matchStat = NOT_MATCH;
1316  0 return null;
1317    }
1318   
1319  2 if (ch == ',') {
1320  1 ch = charAt(index++);
1321  1 continue;
1322    }
1323   
1324  1 if (ch == ']') {
1325  1 ch = charAt(index++);
1326  1 while (isWhitespace(ch)) {
1327  0 ch = charAt(index++);
1328    }
1329  1 break;
1330    }
1331   
1332  0 matchStat = NOT_MATCH;
1333  0 return null;
1334    }
1335  0 } else if (text.startsWith("ull", index)) {
1336  0 index += 3;
1337  0 ch = charAt(index++);
1338  0 list = null;
1339    } else {
1340  0 matchStat = NOT_MATCH;
1341  0 return null;
1342    }
1343   
1344  1 bp = index;
1345  1 if (ch == ',') {
1346  1 this.ch = charAt(bp);
1347  1 matchStat = VALUE;
1348  1 return list;
1349  0 } else if (ch == '}') {
1350  0 ch = charAt(bp);
1351  0 for (;;) {
1352  0 if (ch == ',') {
1353  0 token = JSONToken.COMMA;
1354  0 this.ch = charAt(++bp);
1355  0 break;
1356  0 } else if (ch == ']') {
1357  0 token = JSONToken.RBRACKET;
1358  0 this.ch = charAt(++bp);
1359  0 break;
1360  0 } else if (ch == '}') {
1361  0 token = JSONToken.RBRACE;
1362  0 this.ch = charAt(++bp);
1363  0 break;
1364  0 } else if (ch == EOI) {
1365  0 token = JSONToken.EOF;
1366  0 this.ch = ch;
1367  0 break;
1368    } else {
1369  0 boolean space = false;
1370  0 while (isWhitespace(ch)) {
1371  0 ch = charAt(index++);
1372  0 bp = index;
1373  0 space = true;
1374    }
1375  0 if (space) {
1376  0 continue;
1377    }
1378   
1379  0 matchStat = NOT_MATCH;
1380  0 return null;
1381    }
1382    }
1383   
1384  0 matchStat = END;
1385    } else {
1386  0 this.ch = startChar;
1387  0 bp = startPos;
1388  0 matchStat = NOT_MATCH;
1389  0 return null;
1390    }
1391   
1392  0 return list;
1393    }
1394   
 
1395  36224 toggle public long scanFieldLong(char[] fieldName) {
1396  36224 matchStat = UNKNOWN;
1397  36224 int startPos = this.bp;
1398  36224 char startChar = this.ch;
1399   
1400  36224 if (!charArrayCompare(text, bp, fieldName)) {
1401  57 matchStat = NOT_MATCH_NAME;
1402  57 return 0;
1403    }
1404   
1405  36167 int index = bp + fieldName.length;
1406   
1407  36167 char ch = charAt(index++);
1408   
1409  36167 final boolean quote = ch == '"';
1410  36167 if (quote) {
1411  33 ch = charAt(index++);
1412    }
1413   
1414  36167 boolean negative = false;
1415  36167 if (ch == '-') {
1416  18022 ch = charAt(index++);
1417  18022 negative = true;
1418    }
1419   
1420  36167 long value;
1421  36167 if (ch >= '0' && ch <= '9') {
1422  36130 value = ch - '0';
1423  36130 for (;;) {
1424  680825 ch = charAt(index++);
1425  680825 if (ch >= '0' && ch <= '9') {
1426  644695 value = value * 10 + (ch - '0');
1427  36130 } else if (ch == '.') {
1428  1 matchStat = NOT_MATCH;
1429  1 return 0;
1430    } else {
1431  36129 if (quote) {
1432  16 if (ch != '"') {
1433  0 matchStat = NOT_MATCH;
1434  0 return 0;
1435    } else {
1436  16 ch = charAt(index++);
1437    }
1438    }
1439   
1440  36128 if (ch == ',' || ch == '}') {
1441  36118 bp = index - 1;
1442    }
1443  36128 break;
1444    }
1445    }
1446   
1447  36128 boolean valid = value >= 0 || (value == -9223372036854775808L && negative);
1448  36128 if (!valid) {
1449  3 this.bp = startPos;
1450  3 this.ch = startChar;
1451  3 matchStat = NOT_MATCH;
1452  3 return 0;
1453    }
1454    } else {
1455  37 this.bp = startPos;
1456  37 this.ch = startChar;
1457  37 matchStat = NOT_MATCH;
1458  37 return 0;
1459    }
1460   
1461  36125 for (;;) {
1462  36129 if (ch == ',') {
1463  65 this.ch = charAt(++bp);
1464  65 matchStat = VALUE;
1465  65 token = JSONToken.COMMA;
1466  65 return negative ? -value : value;
1467  36064 } else if (ch == '}') {
1468  36054 ch = charAt(++bp);
1469  36054 for (;;) {
1470  36058 if (ch == ',') {
1471  10241 token = JSONToken.COMMA;
1472  10241 this.ch = charAt(++bp);
1473  10241 break;
1474  25817 } else if (ch == ']') {
1475  7 token = JSONToken.RBRACKET;
1476  7 this.ch = charAt(++bp);
1477  7 break;
1478  25810 } else if (ch == '}') {
1479  2 token = JSONToken.RBRACE;
1480  2 this.ch = charAt(++bp);
1481  2 break;
1482  25808 } else if (ch == EOI) {
1483  25803 token = JSONToken.EOF;
1484  25803 break;
1485  5 } else if (isWhitespace(ch)) {
1486  4 ch = charAt(++bp);
1487    } else {
1488  1 this.bp = startPos;
1489  1 this.ch = startChar;
1490  1 matchStat = NOT_MATCH;
1491  1 return 0;
1492    }
1493    }
1494  36053 matchStat = END;
1495  36053 break;
1496  10 } else if (isWhitespace(ch)) {
1497  4 bp = index;
1498  4 ch = charAt(index++);
1499  4 continue;
1500    } else {
1501  6 matchStat = NOT_MATCH;
1502  6 return 0;
1503    }
1504    }
1505   
1506  36053 return negative ? -value : value;
1507    }
1508   
 
1509  223 toggle public boolean scanFieldBoolean(char[] fieldName) {
1510  223 matchStat = UNKNOWN;
1511   
1512  223 if (!charArrayCompare(text, bp, fieldName)) {
1513  103 matchStat = NOT_MATCH_NAME;
1514  103 return false;
1515    }
1516   
1517  120 int startPos = bp;
1518  120 int index = bp + fieldName.length;
1519   
1520  120 char ch = charAt(index++);
1521   
1522  120 final boolean quote = ch == '"';
1523  120 if (quote) {
1524  12 ch = charAt(index++);
1525    }
1526   
1527  120 boolean value;
1528  120 if (ch == 't') {
1529  45 if (charAt(index++) != 'r') {
1530  1 matchStat = NOT_MATCH;
1531  1 return false;
1532    }
1533  44 if (charAt(index++) != 'u') {
1534  1 matchStat = NOT_MATCH;
1535  1 return false;
1536    }
1537  43 if (charAt(index++) != 'e') {
1538  1 matchStat = NOT_MATCH;
1539  1 return false;
1540    }
1541   
1542  42 if (quote && charAt(index++) != '"') {
1543  0 matchStat = NOT_MATCH;
1544  0 return false;
1545    }
1546   
1547  42 bp = index;
1548  42 ch = charAt(bp);
1549  42 value = true;
1550  75 } else if (ch == 'f') {
1551  41 if (charAt(index++) != 'a') {
1552  1 matchStat = NOT_MATCH;
1553  1 return false;
1554    }
1555  40 if (charAt(index++) != 'l') {
1556  1 matchStat = NOT_MATCH;
1557  1 return false;
1558    }
1559  39 if (charAt(index++) != 's') {
1560  1 matchStat = NOT_MATCH;
1561  1 return false;
1562    }
1563  38 if (charAt(index++) != 'e') {
1564  1 matchStat = NOT_MATCH;
1565  1 return false;
1566    }
1567   
1568  37 if (quote && charAt(index++) != '"') {
1569  0 matchStat = NOT_MATCH;
1570  0 return false;
1571    }
1572   
1573  37 bp = index;
1574  37 ch = charAt(bp);
1575  37 value = false;
1576  34 } else if (ch == '1') {
1577  9 if (quote && charAt(index++) != '"') {
1578  0 matchStat = NOT_MATCH;
1579  0 return false;
1580    }
1581   
1582  9 bp = index;
1583  9 ch = charAt(bp);
1584  9 value = true;
1585  25 } else if (ch == '0') {
1586  2 if (quote && charAt(index++) != '"') {
1587  0 matchStat = NOT_MATCH;
1588  0 return false;
1589    }
1590   
1591  2 bp = index;
1592  2 ch = charAt(bp);
1593  2 value = false;
1594    } else {
1595  23 matchStat = NOT_MATCH;
1596  23 return false;
1597    }
1598   
1599  90 for (;;) {
1600  100 if (ch == ',') {
1601  41 this.ch = charAt(++bp);
1602  41 matchStat = VALUE;
1603  41 token = JSONToken.COMMA;
1604  41 break;
1605  59 } else if (ch == '}') {
1606  45 ch = charAt(++bp);
1607  45 for (;;) {
1608  53 if (ch == ',') {
1609  0 token = JSONToken.COMMA;
1610  0 this.ch = charAt(++bp);
1611  52 } else if (ch == ']') {
1612  0 token = JSONToken.RBRACKET;
1613  0 this.ch = charAt(++bp);
1614  52 } else if (ch == '}') {
1615  5 token = JSONToken.RBRACE;
1616  5 this.ch = charAt(++bp);
1617  47 } else if (ch == EOI) {
1618  37 token = JSONToken.EOF;
1619  10 } else if (isWhitespace(ch)) {
1620  9 ch = charAt(++bp);
1621  9 continue;
1622    } else {
1623  1 matchStat = NOT_MATCH;
1624  1 return false;
1625    }
1626  44 break;
1627    }
1628  44 matchStat = END;
1629  44 break;
1630  14 } else if (isWhitespace(ch)) {
1631  10 ch = charAt(++bp);
1632    } else {
1633  4 bp = startPos;
1634  4 ch = charAt(bp);
1635  4 matchStat = NOT_MATCH;
1636  4 return false;
1637    }
1638    }
1639   
1640  85 return value;
1641    }
1642   
 
1643  73 toggle public final int scanInt(char expectNext) {
1644  73 matchStat = UNKNOWN;
1645   
1646  73 final int mark = bp;
1647  73 int offset = bp;
1648  73 char chLocal = charAt(offset++);
1649   
1650  74 while (isWhitespace(chLocal)) {
1651  1 chLocal = charAt(offset++);
1652    }
1653   
1654  73 final boolean quote = chLocal == '"';
1655   
1656  73 if (quote) {
1657  3 chLocal = charAt(offset++);
1658    }
1659   
1660  73 final boolean negative = chLocal == '-';
1661  73 if (negative) {
1662  9 chLocal = charAt(offset++);
1663    }
1664   
1665  73 int value;
1666  73 if (chLocal >= '0' && chLocal <= '9') {
1667  67 value = chLocal - '0';
1668  67 for (;;) {
1669  208 chLocal = charAt(offset++);
1670  208 if (chLocal >= '0' && chLocal <= '9') {
1671  144 int value_10 = value * 10;
1672  144 if (value_10 < value) {
1673  3 throw new JSONException("parseInt error : "
1674    + subString(mark, offset - 1));
1675    }
1676  141 value = value_10 + (chLocal - '0');
1677  63 } else if (chLocal == '.') {
1678  0 matchStat = NOT_MATCH;
1679  0 return 0;
1680    } else {
1681  63 if (quote) {
1682  1 if (chLocal != '"') {
1683  0 matchStat = NOT_MATCH;
1684  0 return 0;
1685    } else {
1686  1 chLocal = charAt(offset++);
1687    }
1688    }
1689  63 break;
1690    }
1691    }
1692  62 if (value < 0) {
1693  0 matchStat = NOT_MATCH;
1694  0 return 0;
1695    }
1696  2 } else if (chLocal == 'n'
1697    && charAt(offset++) == 'u'
1698    && charAt(offset++) == 'l'
1699    && charAt(offset++) == 'l') {
1700  2 matchStat = VALUE_NULL;
1701  2 value = 0;
1702  2 chLocal = charAt(offset++);
1703   
1704  2 if (quote && chLocal == '"') {
1705  2 chLocal = charAt(offset++);
1706    }
1707   
1708  2 for (;;) {
1709  3 if (chLocal == ',') {
1710  1 bp = offset;
1711  1 this.ch = charAt(bp);
1712  1 matchStat = VALUE_NULL;
1713  1 token = JSONToken.COMMA;
1714  1 return value;
1715  2 } else if (chLocal == ']') {
1716  1 bp = offset;
1717  1 this.ch = charAt(bp);
1718  1 matchStat = VALUE_NULL;
1719  1 token = JSONToken.RBRACKET;
1720  1 return value;
1721  1 } else if (isWhitespace(chLocal)) {
1722  1 chLocal = charAt(offset++);
1723  1 continue;
1724    }
1725  0 break;
1726    }
1727  0 matchStat = NOT_MATCH;
1728  0 return 0;
1729    } else {
1730  0 matchStat = NOT_MATCH;
1731  0 return 0;
1732    }
1733   
1734  62 for (;;) {
1735  66 if (chLocal == expectNext) {
1736  58 bp = offset;
1737  58 this.ch = charAt(bp);
1738  58 matchStat = VALUE;
1739  58 token = JSONToken.COMMA;
1740  58 return negative ? -value : value;
1741    } else {
1742  4 if (isWhitespace(chLocal)) {
1743  4 chLocal = charAt(offset++);
1744  4 continue;
1745    }
1746  0 matchStat = NOT_MATCH;
1747  0 return negative ? -value : value;
1748    }
1749    }
1750    }
1751   
 
1752  1000034 toggle public double scanDouble(char seperator) {
1753  1000034 matchStat = UNKNOWN;
1754   
1755  1000034 int offset = bp;
1756  1000034 char chLocal = charAt(offset++);
1757  1000034 final boolean quote = chLocal == '"';
1758  1000034 if (quote) {
1759  15 chLocal = charAt(offset++);
1760    }
1761   
1762  1000034 boolean negative = chLocal == '-';
1763  1000034 if (negative) {
1764  4 chLocal = charAt(offset++);
1765    }
1766   
1767  1000034 double value;
1768  1000034 if (chLocal >= '0' && chLocal <= '9') {
1769  1000030 long intVal = chLocal - '0';
1770  1000030 for (; ; ) {
1771  1000044 chLocal = charAt(offset++);
1772  1000044 if (chLocal >= '0' && chLocal <= '9') {
1773  14 intVal = intVal * 10 + (chLocal - '0');
1774  14 continue;
1775    } else {
1776  1000030 break;
1777    }
1778    }
1779   
1780  1000030 long power = 1;
1781  1000030 boolean small = (chLocal == '.');
1782  1000028 if (small) {
1783  1000028 chLocal = charAt(offset++);
1784  1000026 if (chLocal >= '0' && chLocal <= '9') {
1785  1000026 intVal = intVal * 10 + (chLocal - '0');
1786  1000026 power = 10;
1787  1000026 for (; ; ) {
1788  16265401 chLocal = charAt(offset++);
1789  16265401 if (chLocal >= '0' && chLocal <= '9') {
1790  15265375 intVal = intVal * 10 + (chLocal - '0');
1791  15265375 power *= 10;
1792  15265375 continue;
1793    } else {
1794  1000026 break;
1795    }
1796    }
1797    } else {
1798  0 matchStat = NOT_MATCH;
1799  0 return 0;
1800    }
1801    }
1802   
1803  1000028 boolean exp = chLocal == 'e' || chLocal == 'E';
1804  1000028 if (exp) {
1805  1030 chLocal = charAt(offset++);
1806  1030 if (chLocal == '+' || chLocal == '-') {
1807  1030 chLocal = charAt(offset++);
1808    }
1809  1030 for (; ; ) {
1810  2060 if (chLocal >= '0' && chLocal <= '9') {
1811  1030 chLocal = charAt(offset++);
1812    } else {
1813  1030 break;
1814    }
1815    }
1816    }
1817   
1818  1000028 int start, count;
1819  1000028 if (quote) {
1820  11 if (chLocal != '"') {
1821  0 matchStat = NOT_MATCH;
1822  0 return 0;
1823    } else {
1824  11 chLocal = charAt(offset++);
1825    }
1826  11 start = bp + 1;
1827  11 count = offset - start - 2;
1828    } else {
1829  1000017 start = bp;
1830  1000017 count = offset - start - 1;
1831    }
1832   
1833  1000028 if (!exp && count < 18) {
1834  74443 value = ((double) intVal) / power;
1835  74443 if (negative) {
1836  4 value = -value;
1837    }
1838    } else {
1839  925585 String text = this.subString(start, count);
1840  925585 value = Double.parseDouble(text);
1841    }
1842  2 } else if (chLocal == 'n'
1843    && charAt(offset++) == 'u'
1844    && charAt(offset++) == 'l'
1845    && charAt(offset++) == 'l') {
1846  2 matchStat = VALUE_NULL;
1847  2 value = 0;
1848  2 chLocal = charAt(offset++);
1849   
1850  2 if (quote && chLocal == '"') {
1851  2 chLocal = charAt(offset++);
1852    }
1853   
1854  2 for (;;) {
1855  3 if (chLocal == ',') {
1856  1 bp = offset;
1857  1 this.ch = charAt(bp);
1858  1 matchStat = VALUE_NULL;
1859  1 token = JSONToken.COMMA;
1860  1 return value;
1861  2 } else if (chLocal == ']') {
1862  1 bp = offset;
1863  1 this.ch = charAt(bp);
1864  1 matchStat = VALUE_NULL;
1865  1 token = JSONToken.RBRACKET;
1866  1 return value;
1867  1 } else if (isWhitespace(chLocal)) {
1868  1 chLocal = charAt(offset++);
1869  1 continue;
1870    }
1871  0 break;
1872    }
1873  0 matchStat = NOT_MATCH;
1874  0 return 0;
1875    } else {
1876  0 matchStat = NOT_MATCH;
1877  0 return 0;
1878    }
1879   
1880  1000026 if (chLocal == seperator) {
1881  1000026 bp = offset;
1882  1000026 this.ch = this.charAt(bp);
1883  1000026 matchStat = VALUE;
1884  1000026 token = JSONToken.COMMA;
1885  1000026 return value;
1886    } else {
1887  0 matchStat = NOT_MATCH;
1888  0 return value;
1889    }
1890    }
1891   
 
1892  2091 toggle public long scanLong(char seperator) {
1893  2091 matchStat = UNKNOWN;
1894   
1895  2091 int offset = bp;
1896  2091 char chLocal = charAt(offset++);
1897  2091 final boolean quote = chLocal == '"';
1898   
1899  2091 if (quote) {
1900  3 chLocal = charAt(offset++);
1901    }
1902   
1903  2091 final boolean negative = chLocal == '-';
1904  2091 if (negative) {
1905  1078 chLocal = charAt(offset++);
1906    }
1907   
1908  2091 long value;
1909  2091 if (chLocal >= '0' && chLocal <= '9') {
1910  2085 value = chLocal - '0';
1911  2085 for (;;) {
1912  38943 chLocal = charAt(offset++);
1913  38943 if (chLocal >= '0' && chLocal <= '9') {
1914  36858 value = value * 10 + (chLocal - '0');
1915  2084 } else if (chLocal == '.') {
1916  0 matchStat = NOT_MATCH;
1917  0 return 0;
1918    } else {
1919  2084 if (quote) {
1920  1 if (chLocal != '"') {
1921  0 matchStat = NOT_MATCH;
1922  0 return 0;
1923    } else {
1924  1 chLocal = charAt(offset++);
1925    }
1926    }
1927  2084 break;
1928    }
1929    }
1930   
1931  2084 boolean valid = value >= 0 || (value == -9223372036854775808L && negative);
1932  2084 if (!valid) {
1933  3 matchStat = NOT_MATCH;
1934  3 return 0;
1935    }
1936  2 } else if (chLocal == 'n'
1937    && charAt(offset++) == 'u'
1938    && charAt(offset++) == 'l'
1939    && charAt(offset++) == 'l') {
1940  2 matchStat = VALUE_NULL;
1941  2 value = 0;
1942  2 chLocal = charAt(offset++);
1943   
1944  2 if (quote && chLocal == '"') {
1945  2 chLocal = charAt(offset++);
1946    }
1947   
1948  2 for (;;) {
1949  3 if (chLocal == ',') {
1950  1 bp = offset;
1951  1 this.ch = charAt(bp);
1952  1 matchStat = VALUE_NULL;
1953  1 token = JSONToken.COMMA;
1954  1 return value;
1955  2 } else if (chLocal == ']') {
1956  1 bp = offset;
1957  1 this.ch = charAt(bp);
1958  1 matchStat = VALUE_NULL;
1959  1 token = JSONToken.RBRACKET;
1960  1 return value;
1961  1 } else if (isWhitespace(chLocal)) {
1962  1 chLocal = charAt(offset++);
1963  1 continue;
1964    }
1965  0 break;
1966    }
1967  0 matchStat = NOT_MATCH;
1968  0 return 0;
1969    } else {
1970  0 matchStat = NOT_MATCH;
1971  0 return 0;
1972    }
1973   
1974  2081 for (;;) {
1975  2085 if (chLocal == seperator) {
1976  2076 bp = offset;
1977  2076 this.ch = charAt(bp);
1978  2076 matchStat = VALUE;
1979  2076 token = JSONToken.COMMA;
1980  2076 return negative ? -value : value;
1981    } else {
1982  4 if (isWhitespace(chLocal)) {
1983  4 chLocal = charAt(offset++);
1984  4 continue;
1985    }
1986   
1987  0 matchStat = NOT_MATCH;
1988  0 return value;
1989    }
1990    }
1991    }
1992   
 
1993  7 toggle public java.util.Date scanDate(char seperator) {
1994  7 matchStat = UNKNOWN;
1995  7 int startPos = this.bp;
1996  7 char startChar = this.ch;
1997   
1998  7 int index = bp;
1999   
2000  7 char ch = charAt(index++);
2001   
2002  7 final java.util.Date dateVal;
2003  7 if (ch == '"') {
2004  2 int startIndex = index;
2005  2 int endIndex = indexOf('"', startIndex);
2006  2 if (endIndex == -1) {
2007  0 throw new JSONException("unclosed str");
2008    }
2009   
2010  2 int rest = endIndex - startIndex;
2011  2 bp = index;
2012  2 if (scanISO8601DateIfMatch(false, rest)) {
2013  2 dateVal = calendar.getTime();
2014    } else {
2015  0 bp = startPos;
2016  0 this.ch = startChar;
2017  0 matchStat = NOT_MATCH;
2018  0 return null;
2019    }
2020  2 ch = charAt(endIndex + 1);
2021  2 bp = startPos;
2022   
2023  2 for (; ; ) {
2024  2 if (ch == ',' || ch == ']') {
2025  2 bp = endIndex + 1;
2026  2 this.ch = ch;
2027  2 break;
2028  0 } else if (isWhitespace(ch)) {
2029  0 endIndex++;
2030  0 ch = charAt(endIndex + 1);
2031    } else {
2032  0 this.bp = startPos;
2033  0 this.ch = startChar;
2034  0 matchStat = NOT_MATCH;
2035   
2036  0 return null;
2037    }
2038    }
2039  5 } else if (ch == '-' || (ch >= '0' && ch <= '9')) {
2040  3 long millis = 0;
2041   
2042  3 boolean negative = false;
2043  3 if (ch == '-') {
2044  0 ch = charAt(index++);
2045  0 negative = true;
2046    }
2047   
2048  3 if (ch >= '0' && ch <= '9') {
2049  3 millis = ch - '0';
2050  3 for (; ; ) {
2051  39 ch = charAt(index++);
2052  39 if (ch >= '0' && ch <= '9') {
2053  36 millis = millis * 10 + (ch - '0');
2054    } else {
2055  3 if (ch == ',' || ch == ']') {
2056  3 bp = index - 1;
2057    }
2058  3 break;
2059    }
2060    }
2061    }
2062   
2063  3 if (millis < 0) {
2064  0 this.bp = startPos;
2065  0 this.ch = startChar;
2066  0 matchStat = NOT_MATCH;
2067  0 return null;
2068    }
2069   
2070  3 if (negative) {
2071  0 millis = -millis;
2072    }
2073   
2074  3 dateVal = new java.util.Date(millis);
2075  2 } else if (ch == 'n'
2076    && charAt(index++) == 'u'
2077    && charAt(index++) == 'l'
2078    && charAt(index++) == 'l') {
2079  2 dateVal = null;
2080  2 ch = charAt(index);
2081  2 bp = index;
2082    } else {
2083  0 this.bp = startPos;
2084  0 this.ch = startChar;
2085  0 matchStat = NOT_MATCH;
2086   
2087  0 return null;
2088    }
2089   
2090  7 if (ch == ',') {
2091  4 this.ch = charAt(++bp);
2092  4 matchStat = VALUE;
2093  4 return dateVal;
2094    } else {
2095    //condition ch == '}' is always 'true'
2096  3 ch = charAt(++bp);
2097  3 if (ch == ',') {
2098  0 token = JSONToken.COMMA;
2099  0 this.ch = charAt(++bp);
2100  3 } else if (ch == ']') {
2101  0 token = JSONToken.RBRACKET;
2102  0 this.ch = charAt(++bp);
2103  3 } else if (ch == '}') {
2104  0 token = JSONToken.RBRACE;
2105  0 this.ch = charAt(++bp);
2106  3 } else if (ch == EOI) {
2107  3 this.ch = EOI;
2108  3 token = JSONToken.EOF;
2109    } else {
2110  0 this.bp = startPos;
2111  0 this.ch = startChar;
2112  0 matchStat = NOT_MATCH;
2113  0 return null;
2114    }
2115  3 matchStat = END;
2116    }
2117  3 return dateVal;
2118    }
2119   
 
2120  33 toggle protected final void arrayCopy(int srcPos, char[] dest, int destPos, int length) {
2121  33 text.getChars(srcPos, srcPos + length, dest, destPos);
2122    }
2123   
 
2124  97 toggle public String info() {
2125  97 StringBuilder buf = new StringBuilder();
2126   
2127    // buf.append("pos ").append(bp);
2128    // return "pos " + bp //
2129    // + ", json : " //
2130    // + (text.length() < 65536 //
2131    // ? text //
2132    // : text.substring(0, 65536));
2133   
2134  97 int line = 1;
2135  97 int column = 1;
2136  811 for (int i = 0; i < bp; ++i, column++) {
2137  714 char ch = text.charAt(i);
2138  714 if (ch == '\n') {
2139  0 column = 1;
2140  0 line++;
2141    }
2142    }
2143   
2144  97 buf.append("pos ").append(bp)
2145    .append(", line ").append(line)
2146    .append(", column ").append(column);
2147   
2148  97 if (text.length() < 65535) {
2149  97 buf.append(text);
2150    } else {
2151  0 buf.append(text.substring(0, 65535));
2152    }
2153   
2154  97 return buf.toString();
2155    }
2156   
2157    // for hsf support
 
2158  26 toggle public String[] scanFieldStringArray(char[] fieldName, int argTypesCount, SymbolTable typeSymbolTable) {
2159  26 int startPos = bp;
2160  26 char starChar = ch;
2161   
2162  140 while (isWhitespace(ch)) {
2163  114 next();
2164    }
2165   
2166  26 int offset;
2167  26 char ch;
2168  26 if (fieldName != null) {
2169  17 matchStat = UNKNOWN;
2170  17 if (!charArrayCompare(fieldName)) {
2171  7 matchStat = NOT_MATCH_NAME;
2172  7 return null;
2173    }
2174   
2175  10 offset = bp + fieldName.length;
2176  10 ch = text.charAt(offset++);
2177  22 while (isWhitespace(ch)) {
2178  12 ch = text.charAt(offset++);
2179    }
2180   
2181  10 if (ch == ':') {
2182  10 ch = text.charAt(offset++);
2183    } else {
2184  0 matchStat = NOT_MATCH;
2185  0 return null;
2186    }
2187   
2188  24 while (isWhitespace(ch)) {
2189  14 ch = text.charAt(offset++);
2190    }
2191    } else {
2192  9 offset = bp + 1;
2193  9 ch = this.ch;
2194    }
2195   
2196  19 if (ch == '[') {
2197  18 bp = offset;
2198  18 this.ch = text.charAt(bp);
2199  1 } else if (ch == 'n' && text.startsWith("ull", bp + 1)) {
2200  1 bp += 4;
2201  1 this.ch = text.charAt(bp);
2202  1 return null;
2203    } else {
2204  0 matchStat = NOT_MATCH;
2205  0 return null;
2206    }
2207   
2208  18 String[] types = argTypesCount >= 0 ? new String[argTypesCount] : new String[4];
2209  18 int typeIndex = 0;
2210  18 for (;;) {
2211  50 while (isWhitespace(this.ch)) {
2212  20 next();
2213    }
2214   
2215  30 if (this.ch != '\"') {
2216  2 this.bp = startPos;
2217  2 this.ch = starChar;
2218  2 matchStat = NOT_MATCH;
2219  2 return null;
2220    }
2221   
2222  28 String type = scanSymbol(typeSymbolTable, '"');
2223  28 if (typeIndex == types.length) {
2224  0 int newCapacity = types.length + (types.length >> 1) + 1;
2225  0 String[] array = new String[newCapacity];
2226  0 System.arraycopy(types, 0, array, 0, types.length);
2227  0 types = array;
2228    }
2229  28 types[typeIndex++] = type;
2230  28 while (isWhitespace(this.ch)) {
2231  0 next();
2232    }
2233  28 if (this.ch == ',') {
2234  12 next();
2235  12 continue;
2236    }
2237  16 break;
2238    }
2239  16 if (types.length != typeIndex) {
2240  16 String[] array = new String[typeIndex];
2241  16 System.arraycopy(types, 0, array, 0, typeIndex);
2242  16 types = array;
2243    }
2244   
2245  16 while (isWhitespace(this.ch)) {
2246  0 next();
2247    }
2248   
2249  16 if (this.ch == ']') {
2250  16 next();
2251    } else {
2252  0 this.bp = startPos;
2253  0 this.ch = starChar;
2254  0 matchStat = NOT_MATCH;
2255  0 return null;
2256    }
2257   
2258  16 return types;
2259    }
2260   
 
2261  12 toggle public boolean matchField2(char[] fieldName) {
2262  64 while (isWhitespace(ch)) {
2263  52 next();
2264    }
2265   
2266  12 if (!charArrayCompare(fieldName)) {
2267  0 matchStat = NOT_MATCH_NAME;
2268  0 return false;
2269    }
2270   
2271  12 int offset = bp + fieldName.length;
2272  12 char ch = text.charAt(offset++);
2273  36 while (isWhitespace(ch)) {
2274  24 ch = text.charAt(offset++);
2275    }
2276   
2277  12 if (ch == ':') {
2278  12 this.bp = offset;
2279  12 this.ch = charAt(bp);
2280  12 return true;
2281    } else {
2282  0 matchStat = NOT_MATCH_NAME;
2283  0 return false;
2284    }
2285    }
2286   
 
2287  0 toggle public final void skipObject() {
2288  0 skipObject(false);
2289    }
2290   
 
2291  81 toggle public final void skipObject(boolean valid) {
2292  81 boolean quote = false;
2293  81 int braceCnt = 0;
2294  81 int i = bp;
2295  4400 for (; i < text.length(); ++i) {
2296  4386 final char ch = text.charAt(i);
2297  4386 if (ch == '\\') {
2298  0 if (i < len - 1) {
2299  0 ++i;
2300  0 continue;
2301    } else {
2302  0 this.ch = ch;
2303  0 this.bp = i;
2304  0 throw new JSONException("illegal str, " + info());
2305    }
2306  4386 } else if (ch == '"') {
2307  520 quote = !quote;
2308  3866 } else if (ch == '{') {
2309  20 if (quote) {
2310  0 continue;
2311    }
2312  20 braceCnt++;
2313  3846 } else if (ch == '}') {
2314  87 if (quote) {
2315  2 continue;
2316    } else {
2317  85 braceCnt--;
2318    }
2319  85 if (braceCnt == -1) {
2320  67 this.bp = i + 1;
2321  67 if (this.bp == text.length()) {
2322  14 this.ch = EOI;
2323  14 this.token = JSONToken.EOF;
2324  14 return;
2325    }
2326  53 this.ch = text.charAt(this.bp);
2327  53 if (this.ch == ',') {
2328  38 token = JSONToken.COMMA;
2329  38 int index = ++bp;
2330  38 this.ch = (index >= text.length() //
2331    ? EOI //
2332    : text.charAt(index));
2333  38 return;
2334  15 } else if (this.ch == '}') {
2335  2 token = JSONToken.RBRACE;
2336  2 next();
2337  2 return;
2338  13 } else if (this.ch == ']') {
2339  9 token = JSONToken.RBRACKET;
2340  9 next();
2341  9 return;
2342    } else {
2343  4 nextToken(JSONToken.COMMA);
2344    }
2345  4 return;
2346    }
2347    }
2348    }
2349   
2350  14 if (i == text.length()) {
2351  12 throw new JSONException("illegal str, " + info());
2352    }
2353    }
2354   
 
2355  0 toggle public final void skipArray() {
2356  0 skipArray(false);
2357    }
2358   
 
2359  30 toggle public final void skipArray(boolean valid) {
2360  30 boolean quote = false;
2361  30 int bracketCnt = 0;
2362  30 int i = bp;
2363  815 for (; i < text.length(); ++i) {
2364  809 char ch = text.charAt(i);
2365  809 if (ch == '\\') {
2366  0 if (i < len - 1) {
2367  0 ++i;
2368  0 continue;
2369    } else {
2370  0 this.ch = ch;
2371  0 this.bp = i;
2372  0 throw new JSONException("illegal str, " + info());
2373    }
2374  809 } else if (ch == '"') {
2375  92 quote = !quote;
2376  717 } else if (ch == '[') {
2377  8 if (quote) {
2378  0 continue;
2379    }
2380  8 bracketCnt++;
2381  709 } else if (ch == '{' && valid) {
2382    {
2383  18 int index = ++bp;
2384  18 this.ch = (index >= text.length() //
2385    ? EOI //
2386    : text.charAt(index));
2387    }
2388   
2389  18 skipObject(valid);
2390  691 } else if (ch == ']') {
2391  26 if (quote) {
2392  0 continue;
2393    } else {
2394  26 bracketCnt--;
2395    }
2396  26 if (bracketCnt == -1) {
2397  18 this.bp = i + 1;
2398  18 if (this.bp == text.length()) {
2399  14 this.ch = EOI;
2400  14 token = JSONToken.EOF;
2401  14 return;
2402    }
2403  4 this.ch = text.charAt(this.bp);
2404  4 nextToken(JSONToken.COMMA);
2405  4 return;
2406    }
2407    }
2408    }
2409   
2410  6 if (i == text.length()) {
2411  6 throw new JSONException("illegal str, " + info());
2412    }
2413    }
2414   
 
2415  511 toggle public final void skipString() {
2416  511 if (ch == '"') {
2417  6172 for (int i = bp + 1; i < text.length(); ++i) {
2418  6172 char c = text.charAt(i);
2419  6172 if (c == '\\') {
2420  28 if (i < len - 1) {
2421  28 ++i;
2422  28 continue;
2423    }
2424  6144 } else if (c == '"') {
2425  511 this.ch = text.charAt(bp = i + 1);
2426  511 return;
2427    }
2428    }
2429  0 throw new JSONException("unclosed str");
2430    } else {
2431  0 throw new UnsupportedOperationException();
2432    }
2433    }
2434   
 
2435  27 toggle public boolean seekArrayToItem(int index) {
2436  27 if (index < 0) {
2437  0 throw new IllegalArgumentException("index must > 0, but " + index);
2438    }
2439   
2440  27 if (token == JSONToken.EOF) {
2441  2 return false;
2442    }
2443   
2444  25 if (token != JSONToken.LBRACKET) {
2445  0 throw new UnsupportedOperationException();
2446    }
2447    // nextToken();
2448   
2449  61 for (int i = 0; i < index; ++i) {
2450  37 skipWhitespace();
2451  37 if (ch == '"' || ch == '\'') {
2452  4 skipString();
2453  4 if (ch == ',') {
2454  4 next();
2455  4 continue;
2456  0 } else if (ch == ']') {
2457  0 next();
2458  0 nextToken(JSONToken.COMMA);
2459  0 return false;
2460    } else {
2461  0 throw new JSONException("illegal json.");
2462    }
2463  33 } else if (ch == '{') {
2464  26 next();
2465  26 token = JSONToken.LBRACE;
2466  26 skipObject(false);
2467  7 } else if (ch == '[') {
2468  3 next();
2469  3 token = JSONToken.LBRACKET;
2470  3 skipArray(false);
2471    } else {
2472  4 boolean match = false;
2473  11 for (int j = bp + 1; j < text.length(); ++j) {
2474  11 char c = text.charAt(j);
2475  11 if (c == ',') {
2476  3 match = true;
2477  3 bp = j + 1;
2478  3 ch = charAt(bp);
2479  3 break;
2480  8 } else if (c == ']') {
2481  1 bp = j + 1;
2482  1 ch = charAt(bp);
2483  1 nextToken();
2484  1 return false;
2485    }
2486    }
2487   
2488  3 if (!match) {
2489  0 throw new JSONException("illegal json.");
2490    }
2491   
2492  3 continue;
2493    }
2494   
2495  29 if (token == JSONToken.COMMA) {
2496  29 continue;
2497  0 } else if (token == JSONToken.RBRACKET) {
2498  0 return false;
2499    } else {
2500  0 throw new UnsupportedOperationException();
2501    }
2502   
2503    }
2504   
2505  24 nextToken();
2506  24 return true;
2507    }
2508   
 
2509  606 toggle public int seekObjectToField(long fieldNameHash, boolean deepScan) {
2510  606 if (token == JSONToken.EOF) {
2511  2 return JSONLexer.NOT_MATCH;
2512    }
2513   
2514  604 if (token == JSONToken.RBRACE || token == JSONToken.RBRACKET) {
2515  87 nextToken();
2516  87 return JSONLexer.NOT_MATCH;
2517    }
2518   
2519  517 if (token != JSONToken.LBRACE && token != JSONToken.COMMA) {
2520  0 throw new UnsupportedOperationException(JSONToken.name(token));
2521    }
2522   
2523  517 for (;;) {
2524  1454 if (ch == '}') {
2525  132 next();
2526  132 nextToken();
2527  132 return JSONLexer.NOT_MATCH;
2528    }
2529  1322 if (ch == EOI) {
2530  0 return JSONLexer.NOT_MATCH;
2531    }
2532   
2533  1322 if (ch != '"') {
2534  1314 skipWhitespace();
2535    }
2536   
2537  1322 long hash;
2538  1322 if (ch == '"') {
2539  1322 hash = 0xcbf29ce484222325L;
2540   
2541  15967 for (int i = bp + 1; i < text.length(); ++i) {
2542  15967 char c = text.charAt(i);
2543  15967 if (c == '\\') {
2544  0 ++i;
2545  0 if (i == text.length()) {
2546  0 throw new JSONException("unclosed str, " + info());
2547    }
2548  0 c = text.charAt(i);
2549    }
2550   
2551  15967 if (c == '"') {
2552  1322 bp = i + 1;
2553  1322 ch = (bp >= text.length() //
2554    ? EOI //
2555    : text.charAt(bp));
2556  1322 break;
2557    }
2558   
2559  14645 hash ^= c;
2560  14645 hash *= 0x100000001b3L;
2561    }
2562    } else {
2563  0 throw new UnsupportedOperationException();
2564    }
2565   
2566  1322 if (hash == fieldNameHash) {
2567  109 if (ch != ':') {
2568  2 skipWhitespace();
2569    }
2570  109 if (ch == ':') {
2571    {
2572  109 int index = ++bp;
2573  109 ch = (index >= text.length() //
2574    ? EOI //
2575    : text.charAt(index));
2576    }
2577  109 if (ch == ',') {
2578    {
2579  0 int index = ++bp;
2580  0 ch = (index >= text.length() //
2581    ? EOI //
2582    : text.charAt(index));
2583    }
2584  0 token = JSONToken.COMMA;
2585  109 } else if (ch == ']') {
2586    {
2587  0 int index = ++bp;
2588  0 ch = (index >= text.length() //
2589    ? EOI //
2590    : text.charAt(index));
2591    }
2592  0 token = JSONToken.RBRACKET;
2593  109 } else if (ch == '}') {
2594    {
2595  0 int index = ++bp;
2596  0 ch = (index >= text.length() //
2597    ? EOI //
2598    : text.charAt(index));
2599    }
2600  0 token = JSONToken.RBRACE;
2601  109 } else if (ch >= '0' && ch <= '9') {
2602  2 sp = 0;
2603  2 pos = bp;
2604  2 scanNumber();
2605    } else {
2606  107 nextToken(JSONToken.LITERAL_INT);
2607    }
2608    }
2609  109 return VALUE;
2610    }
2611   
2612  1213 if (ch != ':') {
2613  2 skipWhitespace();
2614    }
2615   
2616  1213 if (ch == ':') {
2617  1213 int index = ++bp;
2618  1213 ch = (index >= text.length() //
2619    ? EOI //
2620    : text.charAt(index));
2621    } else {
2622  0 throw new JSONException("illegal json, " + info());
2623    }
2624   
2625  1213 if (ch != '"'
2626    && ch != '\''
2627    && ch != '{'
2628    && ch != '['
2629    && ch != '0'
2630    && ch != '1'
2631    && ch != '2'
2632    && ch != '3'
2633    && ch != '4'
2634    && ch != '5'
2635    && ch != '6'
2636    && ch != '7'
2637    && ch != '8'
2638    && ch != '9'
2639    && ch != '+'
2640    && ch != '-') {
2641  1211 skipWhitespace();
2642    }
2643   
2644    // skip fieldValues
2645  1213 if (ch == '-' || ch == '+' || (ch >= '0' && ch <= '9')) {
2646  309 next();
2647  616 while (ch >= '0' && ch <= '9') {
2648  307 next();
2649    }
2650   
2651    // scale
2652  309 if (ch == '.') {
2653  44 next();
2654  114 while (ch >= '0' && ch <= '9') {
2655  70 next();
2656    }
2657    }
2658   
2659    // exp
2660  309 if (ch == 'E' || ch == 'e') {
2661  0 next();
2662  0 if (ch == '-' || ch == '+') {
2663  0 next();
2664    }
2665  0 while (ch >= '0' && ch <= '9') {
2666  0 next();
2667    }
2668    }
2669   
2670  309 if (ch != ',') {
2671  59 skipWhitespace();
2672    }
2673  309 if (ch == ',') {
2674  250 next();
2675    }
2676  904 } else if (ch == '"') {
2677  507 skipString();
2678   
2679  507 if (ch != ',' && ch != '}') {
2680  49 skipWhitespace();
2681    }
2682   
2683  507 if (ch == ',') {
2684  458 next();
2685    }
2686  397 } else if (ch == 't') {
2687  14 next();
2688  14 if (ch == 'r') {
2689  14 next();
2690  14 if (ch == 'u') {
2691  14 next();
2692  14 if (ch == 'e') {
2693  14 next();
2694    }
2695    }
2696    }
2697   
2698  14 if (ch != ',' && ch != '}') {
2699  2 skipWhitespace();
2700    }
2701   
2702  14 if (ch == ',') {
2703  12 next();
2704    }
2705  383 } else if (ch == 'n') {
2706  54 next();
2707  54 if (ch == 'u') {
2708  54 next();
2709  54 if (ch == 'l') {
2710  54 next();
2711  54 if (ch == 'l') {
2712  54 next();
2713    }
2714    }
2715    }
2716   
2717  54 if (ch != ',' && ch != '}') {
2718  4 skipWhitespace();
2719    }
2720   
2721  54 if (ch == ',') {
2722  50 next();
2723    }
2724  329 } else if (ch == 'f') {
2725  50 next();
2726  50 if (ch == 'a') {
2727  50 next();
2728  50 if (ch == 'l') {
2729  50 next();
2730  50 if (ch == 's') {
2731  50 next();
2732  50 if (ch == 'e') {
2733  50 next();
2734    }
2735    }
2736    }
2737    }
2738   
2739  50 if (ch != ',' && ch != '}') {
2740  4 skipWhitespace();
2741    }
2742   
2743  50 if (ch == ',') {
2744  46 next();
2745    }
2746  279 } else if (ch == '{') {
2747    {
2748  163 int index = ++bp;
2749  163 ch = (index >= text.length() //
2750    ? EOI //
2751    : text.charAt(index));
2752    }
2753  163 if (deepScan) {
2754  160 token = JSONToken.LBRACE;
2755  160 return OBJECT;
2756    }
2757   
2758  3 skipObject(false);
2759  3 if (token == JSONToken.RBRACE) {
2760  1 return JSONLexer.NOT_MATCH;
2761    }
2762  116 } else if (ch == '[') {
2763  116 next();
2764  116 if (deepScan) {
2765  115 token = JSONToken.LBRACKET;
2766  115 return ARRAY;
2767    }
2768  1 skipArray(false);
2769  1 if (token == JSONToken.RBRACE) {
2770  0 return JSONLexer.NOT_MATCH;
2771    }
2772    } else {
2773  0 throw new UnsupportedOperationException();
2774    }
2775    }
2776    }
2777   
 
2778  4 toggle public int seekObjectToField(long[] fieldNameHash) {
2779  4 if (token != JSONToken.LBRACE && token != JSONToken.COMMA) {
2780  0 throw new UnsupportedOperationException();
2781    }
2782   
2783  4 for (;;) {
2784  4 if (ch == '}') {
2785  0 next();
2786  0 nextToken();
2787  0 this.matchStat = JSONLexer.NOT_MATCH;
2788  0 return -1;
2789    }
2790  4 if (ch == EOI) {
2791  0 this.matchStat = JSONLexer.NOT_MATCH;
2792  0 return -1;
2793    }
2794   
2795  4 if (ch != '"') {
2796  4 skipWhitespace();
2797    }
2798   
2799  4 long hash;
2800  4 if (ch == '"') {
2801  4 hash = 0xcbf29ce484222325L;
2802   
2803  24 for (int i = bp + 1; i < text.length(); ++i) {
2804  24 char c = text.charAt(i);
2805  24 if (c == '\\') {
2806  0 ++i;
2807  0 if (i == text.length()) {
2808  0 throw new JSONException("unclosed str, " + info());
2809    }
2810  0 c = text.charAt(i);
2811    }
2812   
2813  24 if (c == '"') {
2814  4 bp = i + 1;
2815  4 ch = (bp >= text.length() //
2816    ? EOI //
2817    : text.charAt(bp));
2818  4 break;
2819    }
2820   
2821  20 hash ^= c;
2822  20 hash *= 0x100000001b3L;
2823    }
2824    } else {
2825  0 throw new UnsupportedOperationException();
2826    }
2827   
2828  4 int matchIndex = -1;
2829  6 for (int i = 0; i < fieldNameHash.length; i++) {
2830  6 if (hash == fieldNameHash[i]) {
2831  4 matchIndex = i;
2832  4 break;
2833    }
2834    }
2835   
2836  4 if (matchIndex != -1) {
2837  4 if (ch != ':') {
2838  4 skipWhitespace();
2839    }
2840  4 if (ch == ':') {
2841    {
2842  4 int index = ++bp;
2843  4 ch = (index >= text.length() //
2844    ? EOI //
2845    : text.charAt(index));
2846    }
2847  4 if (ch == ',') {
2848    {
2849  0 int index = ++bp;
2850  0 ch = (index >= text.length() //
2851    ? EOI //
2852    : text.charAt(index));
2853    }
2854  0 token = JSONToken.COMMA;
2855  4 } else if (ch == ']') {
2856    {
2857  0 int index = ++bp;
2858  0 ch = (index >= text.length() //
2859    ? EOI //
2860    : text.charAt(index));
2861    }
2862  0 token = JSONToken.RBRACKET;
2863  4 } else if (ch == '}') {
2864    {
2865  0 int index = ++bp;
2866  0 ch = (index >= text.length() //
2867    ? EOI //
2868    : text.charAt(index));
2869    }
2870  0 token = JSONToken.RBRACE;
2871  4 } else if (ch >= '0' && ch <= '9') {
2872  0 sp = 0;
2873  0 pos = bp;
2874  0 scanNumber();
2875    } else {
2876  4 nextToken(JSONToken.LITERAL_INT);
2877    }
2878    }
2879   
2880  4 matchStat = VALUE;
2881  4 return matchIndex;
2882    }
2883   
2884  0 if (ch != ':') {
2885  0 skipWhitespace();
2886    }
2887   
2888  0 if (ch == ':') {
2889  0 int index = ++bp;
2890  0 ch = (index >= text.length() //
2891    ? EOI //
2892    : text.charAt(index));
2893    } else {
2894  0 throw new JSONException("illegal json, " + info());
2895    }
2896   
2897  0 if (ch != '"'
2898    && ch != '\''
2899    && ch != '{'
2900    && ch != '['
2901    && ch != '0'
2902    && ch != '1'
2903    && ch != '2'
2904    && ch != '3'
2905    && ch != '4'
2906    && ch != '5'
2907    && ch != '6'
2908    && ch != '7'
2909    && ch != '8'
2910    && ch != '9'
2911    && ch != '+'
2912    && ch != '-') {
2913  0 skipWhitespace();
2914    }
2915   
2916    // skip fieldValues
2917  0 if (ch == '-' || ch == '+' || (ch >= '0' && ch <= '9')) {
2918  0 next();
2919  0 while (ch >= '0' && ch <= '9') {
2920  0 next();
2921    }
2922   
2923    // scale
2924  0 if (ch == '.') {
2925  0 next();
2926  0 while (ch >= '0' && ch <= '9') {
2927  0 next();
2928    }
2929    }
2930   
2931    // exp
2932  0 if (ch == 'E' || ch == 'e') {
2933  0 next();
2934  0 if (ch == '-' || ch == '+') {
2935  0 next();
2936    }
2937  0 while (ch >= '0' && ch <= '9') {
2938  0 next();
2939    }
2940    }
2941   
2942  0 if (ch != ',') {
2943  0 skipWhitespace();
2944    }
2945  0 if (ch == ',') {
2946  0 next();
2947    }
2948  0 } else if (ch == '"') {
2949  0 skipString();
2950   
2951  0 if (ch != ',' && ch != '}') {
2952  0 skipWhitespace();
2953    }
2954   
2955  0 if (ch == ',') {
2956  0 next();
2957    }
2958  0 } else if (ch == '{') {
2959    {
2960  0 int index = ++bp;
2961  0 ch = (index >= text.length() //
2962    ? EOI //
2963    : text.charAt(index));
2964    }
2965   
2966  0 skipObject(false);
2967  0 } else if (ch == '[') {
2968  0 next();
2969   
2970  0 skipArray(false);
2971    } else {
2972  0 throw new UnsupportedOperationException();
2973    }
2974    }
2975    }
2976    }
  • Report generated by OpenClover v 4.5.2 on Tue Apr 9 2024 16:45:45 CDT using coverage data from Tue Apr 9 2024 16:43:32 CDT.
  • OpenClover is free and open-source software.